📘 Free GH-900 Sample Questions
Which of the following keywords are used to link a pull request to an issue? (Choose three.)
A
fix
B
resolves
C
. merge
D
join
E
closed
F
connects
Correct Answer:
A. fix
Explanation:
The correct answer is A (fix), B (resolves), and E (closed). These keywords are specifically designed by GitHub
to automatically link a pull request to an issue and, upon merging the pull request, automatically close that
issue. This automation streamlines workflow management.
fix, fixes: Indicates that the pull request directly addresses and rectifies a problem described in the linked
issue. Upon merging, GitHub will automatically close the linked issue.
resolve, resolves: Similar to fix, it signals that the pull request resolves the problem or implements the feature
detailed in the linked issue. Merging will automatically close the linked issue.
close, closes: Functionally identical to fix and resolves; it signifies that the pull request provides the resolution
to the referenced issue. Merging the pull request will automatically close that issue.
merged.
These keywords offer a convenient and automated mechanism for managing issue tracking in conjunction
with pull requests. They are recognized by GitHub's systems and facilitate a cleaner, more organized
workflow. They eliminate the need for manual issue closure when a pull request addressing that issue is
merge (C), join (D), and connects (F) are not standard GitHub keywords that trigger automatic issue closure.
While "connects" might seem semantically relevant, it doesn't trigger the automated issue linking and closure
functionalities that the correct keywords do. Using these non-standard keywords would require manually
closing the issue. GitHub specifically defined the 'fix', 'resolve', and 'close' family of keywords for this explicit
linkage and resolution purpose.
For further reading, consult GitHub's official documentation on linking a pull request to an issue:
Linking a pull request to an issue
This documentation details exactly which keywords are supported by GitHub to create these associations and
automate issue closures.
Which syntax is used for authoring saved replies?
A
HTML
B
YAML
C
. Markup
D
Markdown
Correct Answer:
D. Markdown
Explanation:
The correct answer is D. Markdown.
GitHub's saved replies, often used to provide consistent and helpful responses to common issues and pull
request comments, leverage Markdown syntax for formatting. Markdown is a lightweight markup language
that is easy to read and write, and it's widely adopted across the web. It allows users to add formatting like
bold text, italics, lists, headings, links, and code snippets without resorting to complex HTML. GitHub's UI
specifically supports rendering Markdown, making it a natural fit for these saved responses.
HTML is a more complex language designed for structuring web pages and not ideal for composing short,
issues.
quick replies. YAML is primarily used for configuration files and data serialization, unsuitable for formatting
text intended for human consumption. While "Markup" is a generic term, it doesn't specify the particular
syntax GitHub employs. Markdown's simplicity and wide usage within the GitHub ecosystem makes it the
practical and intuitive choice for crafting saved replies. GitHub's platform renders the Markdown into
formatted text, so users see the styled output without needing to understand HTML. The choice of Markdown
enables consistency in responses and ensures a clean and professional look when used in comments and
For more information about Markdown and GitHub's implementation, refer to these authoritative links:
GitHub's Mastering Markdown: https://guides.github.com/features/mastering-markdown/
Markdown Guide: https://www.markdownguide.org/
As a user, what feature can you use to merge proposed changes in a repository on GitHub?
A
. discussions
B
projects
C
pull requests
D
issues
Correct Answer:
C. pull requests
Explanation:
The correct answer is C. Pull Requests. Let's break down why:
GitHub is a collaborative platform built around version control using Git. Collaboration often involves many
individuals contributing changes to a central repository. To manage these contributions effectively, GitHub
employs a feature called Pull Requests.
A Pull Request (PR) is essentially a formal proposal to merge changes from a branch into another branch,
usually the main or develop branch. It provides a mechanism for code review, discussion, and eventual
integration. When a user wants to contribute, they create a branch, make their changes, and then open a Pull
Request.
The Pull Request acts as a dedicated space to review the proposed changes. Other collaborators can examine
the code, leave comments, suggest improvements, and ultimately approve or reject the merge. This
collaborative process ensures code quality and reduces the risk of introducing errors.
GitHub automatically performs checks on the Pull Request, such as running tests (if configured). These
checks help to identify potential issues before the code is merged. Only after the review process is complete
and the Pull Request is approved can the changes be merged into the target branch.
A. Discussions are for general conversations and Q&A related to the repository, not for merging code. B.
Projects are for organizing tasks and workflows related to the repository but don't directly merge code. D.
Issues are used for tracking bugs, feature requests, and other tasks, not for the process of merging code.
In summary, Pull Requests are specifically designed for the collaborative merging of code changes in a
GitHub repository. They provide a crucial framework for code review, discussion, and ensuring code quality
within a development workflow.
For further research and authoritative documentation on Pull Requests, refer to the official GitHub
documentation:
GitHub Docs: About Pull Requests
If there are multiple README files, which of the following locations will be displayed first?
A
docs
B
root
C
src
D
.gitHub
Correct Answer:
D. .gitHub
Explanation:
The answer D (.github) is correct because GitHub prioritizes the README file located within the .github
directory for display on a repository's landing page. This is part of GitHub's effort to provide a consistent and
specific information.
organized way to display project information. While README files are typically placed in the root directory (B),
or within other directories like /docs (A) or /src (C), the .github directory holds special significance for
repository-level configurations and descriptions. GitHub specifically searches for a README file in this
directory to use as the primary introduction to the repository, overriding README files in other locations. The
.github directory is commonly used to store community health files, templates, and other configuration details
pertinent to the repository's governance. By prioritizing READMEs in the .github directory, GitHub encourages
maintainers to create a curated and informative introduction specific to their repository when navigating
directly to the codebase. Other README files within subdirectories like /src or /docs are usually intended to
document specific aspects of the code or the project documentation itself, and won't be shown by default on
the main repository page. GitHub's conventions allow for clear organization of documentation and project-
For further research, consult GitHub's official documentation on repository settings and community profile.
You can find information about community health files and default repository settings which contribute to
understanding this behavior. Also, explore the guides on creating a great repository.
Why is branching a core concept in Git?
A
. Branching helps in automatically merging changes from different branches into the main branch.
B
. Branching creates physical copies of the project on disk, ensuring data redundancy and backup.
C
Branching creates an isolated environment to try new ideas and make changes without affecting other
branches.
D
Branching is necessary for organizing files and folders within a Git repository.
Correct Answer:
C. Branching creates an isolated environment to try new ideas and make changes without affecting other
branches.
Explanation:
Branching is a fundamental concept in Git version control, and the correct answer highlights its primary
benefit: creating isolated environments for experimentation. Git branches allow developers to diverge from
the main codebase (typically main or master) to work on new features, bug fixes, or other modifications
without directly altering the stable, production-ready version. This isolation is crucial for agile software
development practices.
Imagine developing a new feature for a cloud-based application. You don't want to introduce instability to the
live system while you're still experimenting. Branching facilitates this by providing a sandboxed environment.
You can make changes, test them thoroughly, and if the feature proves problematic, you can simply discard
the branch without impacting the main codebase.
Furthermore, multiple developers can work on different features simultaneously, each in their own branch.
This parallel development accelerates the software development lifecycle. Once a branch is deemed stable
and ready for integration, it can be merged back into the main branch. Git’s merging capabilities effectively
combine the changes, resolving conflicts as necessary.
Authoritative Links:
Option A is incorrect because branching itself doesn't automatically merge changes. Merging is a separate,
explicit operation that requires user intervention and conflict resolution when necessary. Option B is also
wrong; Git doesn't create physical copies on disk for branches. It uses a more efficient system of pointers and
object references to track changes. Option D is incorrect as branches are about version control and parallel
development, not just organizing files.
The isolated nature of branching aligns with cloud computing principles of modularity and separation of
concerns. By isolating changes, branching minimizes the risk of cascading failures and promotes a more
resilient and maintainable codebase, which is essential in cloud environments. In continuous integration and
continuous delivery (CI/CD) pipelines, branching plays a pivotal role in managing feature releases and
hotfixes, ensuring minimal disruption to the live cloud-based application.
Git Branching - Basic Branching and Merging: https://git-scm.com/book/en/v2/Git-Branching-Basic-
Branching-and-Merging
Understanding Git Branching: https://www.atlassian.com/git/tutorials/using-branches
What is the difference between Git and GitHub?
A
Git is a command-line tool for tracking file changes, while GitHub is a platform for collaborating on Git repositories.
B
Git and GitHub are different names for the same tool that is used for version control and collaboration.
C
Git is a cloud-based hosting service, while GitHub is a distributed version control system.
D
Git is a centralized version control system, while GitHub is a cloud-based collaboration platform
Correct Answer:
A. Git is a command-line tool for tracking file changes, while GitHub is a platform for collaborating on Git repositories.
Explanation:
The correct answer is A because it accurately distinguishes between Git and GitHub based on their core
functionalities. Git is a Distributed Version Control System (DVCS). It's primarily a command-line tool that
resides on your local machine and is responsible for tracking changes to files over time. It manages snapshots
of your project, allowing you to revert to previous versions, compare changes, and collaborate with others.
Think of it as the engine that powers version control.
GitHub, on the other hand, is a web-based platform built around Git. It provides a centralized location (a cloud-
based service) to host Git repositories. This hosting facilitates collaboration amongst developers. GitHub
offers features such as issue tracking, pull requests, code review tools, and project management features
built on top of the fundamental version control functionality provided by Git. It offers a graphical user
interface (GUI) making it easier to manage and collaborate using Git.
because Git is not a centralized version control system. It's distributed.
collaborative software development workflow.
Option B is incorrect because Git and GitHub are distinct tools with different functions. Option C is incorrect
because it reverses the roles; Git is the version control system, not a cloud-based service. Option D is incorrect
In essence, Git enables version control, while GitHub provides the infrastructure and tools to manage and
collaborate on Git repositories in a centralized online environment. GitHub uses Git's technology to enable a
For further research, consider these resources:
Git's official documentation: https://git-scm.com/doc
GitHub's official documentation: https://docs.github.com/en
Atlassian's tutorial on Git vs. GitHub: https://www.atlassian.com/git/tutorials/what-is-git/git-vs-github
What type of operations has Git been optimized for?
A
local file manipulation and offline work
B
remote collaboration and real-time editing
C
cloud-based operations and synchronization
D
web development and browser-based coding
Correct Answer:
A. local file manipulation and offline work
Explanation:
The correct answer is A. local file manipulation and offline work. Git is fundamentally designed to manage
and track changes to files locally on a developer's machine. Its core strength lies in enabling efficient version
control without constant reliance on a network connection. Git's architecture emphasizes local operations for
speed and reliability.
Here's why the other options are less accurate:
B. remote collaboration and real-time editing: While Git facilitates remote collaboration, it's not optimized for
real-time editing in the way collaborative document editors are. Git's collaboration model involves pushing
and pulling changes in batches, not simultaneous real-time modification. Collaboration features are built on
top of the core local version control.
C. cloud-based operations and synchronization: Git can be used with cloud-based repositories (like GitHub,
GitLab, or Azure DevOps), but its primary focus isn't cloud-based operations. The majority of Git commands
(commit, branch, merge, diff, etc.) are executed locally. The cloud serves as a central point for sharing and
synchronizing changes that were initially made offline.
D. web development and browser-based coding: While Git is commonly used in web development workflows,
its utility extends far beyond just web projects. It's applicable to any project that requires version control,
regardless of the programming language or development environment. Git's functionality is independent of
the specific code editor or language used.
Git excels at tracking changes, creating branches for experimentation, merging changes, and reverting to
previous states, all of which can be performed entirely offline. Committing changes, creating branches, and
resolving conflicts happen locally before interacting with a remote repository. This local-first approach
ensures fast performance and allows developers to work effectively even without an internet connection.
When a connection is available, Git enables synchronization with remote repositories for sharing and
collaboration. This synchronization is built on top of the foundation of local version control, highlighting that
local operations are primary to the Git workflow.
Supporting Resources:
Git Official Documentation: https://git-scm.com/doc
Pro Git Book (Online): https://git-scm.com/book/en/v2 - specifically the introductory chapters covering Git
basics.
Which version control system is GitHub built on top of?
A
Subversion
B
Mercurial
C
Git
D
Perforce
Correct Answer:
C. Git
Explanation:
The correct answer is Git. GitHub, at its core, is a web-based platform that provides hosting for version control
using Git. Git is a distributed version control system (DVCS) that allows developers to track changes to their
code, collaborate effectively, and revert to previous versions if needed. GitHub leverages Git's powerful
features, such as branching, merging, and commit history, to facilitate collaborative software development.
Essentially, GitHub acts as a remote repository and a user interface for interacting with Git repositories. It
provides a central location to store and manage Git repositories, accessible by multiple developers.
Developers can clone repositories from GitHub to their local machines, make changes, and then push those
changes back to the remote repository. The platform's functionalities, like pull requests and code reviews, are
tightly integrated with Git's branching model.
GitHub enhances Git's usability with a user-friendly web interface, providing tools for project management,
issue tracking, and collaboration. While other version control systems exist (like Subversion, Mercurial, and
Perforce), GitHub was explicitly built and relies directly on Git for all its version control operations. Therefore,
without Git, GitHub would not exist in its current form and wouldn't be able to offer its core functionalities
related to version control. It uses Git commands and processes to achieve collaborative code management
and version control. The platform's functionality relies completely on the capabilities of Git.
Further research:
Git Official Website: https://git-scm.com/ - Provides comprehensive documentation on Git.
GitHub Documentation: https://docs.github.com/en - Offers extensive information about using GitHub and its
features.
Atlassian Git Tutorial: https://www.atlassian.com/git/tutorials - A good resource for learning about Git
concepts and workflows.
What command should you type to create and switch over to a new branch?
A
git checkout -n newBranchName
B
git checkout -b newBranchName
C
git checkout newBranchName
D
git branch newBranchName
Correct Answer:
B. git checkout -b newBranchName
Explanation:
The correct command to create a new branch and immediately switch to it in Git is git checkout -b
newBranchName. Let's break down why:
git branch newBranchName: This command only creates a new branch named newBranchName. It doesn't
switch you to that branch. After running this, you'd still be on your original branch (e.g., main or master).
git checkout newBranchName: This command switches you to an existing branch called newBranchName. It
assumes the branch already exists. If the branch doesn't exist, Git will throw an error.
git checkout -b newBranchName: This command combines both actions. The -b flag tells git checkout to create
a new branch with the specified name and immediately switch to it. This is a shortcut that's commonly used in
Git workflows to streamline the branch creation and navigation process.
checkout is not typically used in this context for creating and switching to a new branch.
git checkout -n newBranchName: This command is not a standard Git command. The -n option with git
Therefore, using git checkout -b newBranchName saves you a step by creating the branch and switching to it in
one go, improving efficiency. This aligns with the principles of version control efficiency, as you can rapidly
isolate and develop features or fixes on independent branches without affecting the main codebase until
ready to merge. This command is a foundational element of any Git-based workflow, facilitating parallel
development and feature isolation in cloud computing and software development.
Here are some authoritative links for further research:
Git Documentation on Branching: https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell
git checkout Documentation: https://git-scm.com/docs/git-checkout
Atlassian Git Tutorial on Branching: https://www.atlassian.com/git/tutorials/using-branches
The difference between GitHub Enterprise Server (GHES) and GitHub Enterprise Cloud is that GHES:
A
includes authentication with SAML single sign-on and access provisioning with SAML or SCIM.
B
. can be deployed on both Windows and Linux.
C
cannot enable rate limiting.
D
. is a self-hosted solution that allows organizations to have full control over their infrastructure.
Correct Answer:
D. . is a self-hosted solution that allows organizations to have full control over their infrastructure.
Explanation:
The correct answer is D because GitHub Enterprise Server (GHES) distinguishes itself as a self-hosted
solution. This crucial feature provides organizations with complete command and control over their
infrastructure, security protocols, and data residency. Unlike GitHub Enterprise Cloud, where the
infrastructure is managed by GitHub, GHES is deployed within the organization's own data center or private
cloud. This self-hosting aspect becomes paramount for companies with stringent compliance requirements,
data sovereignty concerns, or specific customization needs that cannot be met by a shared, multi-tenant
cloud environment. Organizations can tailor the server environment to precisely match their operational and
security policies.
Option A is incorrect because both GitHub Enterprise Cloud and GitHub Enterprise Server offer authentication
with SAML single sign-on and access provisioning with SAML or SCIM. These are enterprise-grade features
available in both deployment models.
Further research:
Option B is misleading. While GitHub Enterprise Server can be deployed on virtual machines and cloud
platforms supporting Linux, stating it deploys on both Windows and Linux is less precise and doesn't highlight
the core distinction of GHES, which is self-hosting.
Option C is incorrect as GitHub Enterprise Server does indeed support rate limiting. Rate limiting is a critical
feature for managing API usage and preventing abuse in both GitHub Enterprise Cloud and Server.
In summary, the defining characteristic that sets GHES apart is its self-hosted nature, granting organizations
unparalleled control, compliance, and customization capabilities compared to the cloud-hosted alternative.
GitHub Enterprise Server documentation: https://docs.github.com/en/enterprise-server
GitHub Enterprise Cloud documentation: https://docs.github.com/en/enterprise-cloud
Questions: 1-10 out of 235
Continue Full Practice..
GET ALL 235 QUESTIONS